Liczby zespolone w Pythonie: Opanowanie operacji matematycznych i postaci biegunowej

W dziedzinie matematyki i obliczeń naukowych liczby zespolone są fundamentalne. Rozszerzają one koncepcję liczb rzeczywistych, włączając w to składnik urojony, reprezentowany przez jednostkę i, gdzie i² = -1. Python, wszechstronny język programowania szeroko przyjęty w światowych branżach i dyscyplinach akademickich, oferuje solidne wsparcie dla liczb zespolonych, czyniąc skomplikowane operacje matematyczne dostępnymi i wydajnymi.

Ten kompleksowy przewodnik zagłębi się w obsługę liczb zespolonych w Pythonie, badając zarówno ich standardową reprezentację algebraiczną, jak i potężną postać biegunową. Omówimy podstawowe operacje matematyczne i zademonstrujemy, jak wykorzystać współrzędne biegunowe do bardziej intuicyjnego zrozumienia i manipulacji liczbami zespolonymi w różnych zastosowaniach, od przetwarzania sygnałów po mechanikę kwantową.

Zrozumienie liczb zespolonych w Pythonie

Liczba zespolona jest zazwyczaj wyrażana w postaci prostokątnej (lub kartezjańskiej) jako a + bi, gdzie a jest częścią rzeczywistą, a b częścią urojoną. Python natywnie obsługuje liczby zespolone, używając notacji a + bj, gdzie j jest używane zamiast i, aby uniknąć pomyłek z prądem w kontekstach inżynierii elektrycznej. Jednak typ liczby zespolonej w Pythonie działa identycznie, niezależnie od tego, czy użyjesz j czy i jako jednostki urojonej w swoim kodzie.

Tworzenie liczb zespolonych w Pythonie

Tworzenie liczby zespolonej w Pythonie jest proste. Możesz użyć wbudowanej funkcji complex() lub bezpośrednio składni a + bj.

• Używanie funkcji complex():

Funkcja complex() może przyjmować dwa argumenty: część rzeczywistą i część urojoną. Jeśli podany jest tylko jeden argument, jest on traktowany jako część rzeczywista, a część urojona domyślnie wynosi zero. Jeśli nie podano żadnych argumentów, tworzy 0j.

            # Creating complex numbers using complex()
complex_num1 = complex(3, 5)  # Real part 3, Imaginary part 5
print(f"Complex number 1: {complex_num1}")

complex_num2 = complex(7)     # Real part 7, Imaginary part 0
print(f"Complex number 2: {complex_num2}")

complex_num3 = complex(0, -2) # Real part 0, Imaginary part -2
print(f"Complex number 3: {complex_num3}")

complex_num4 = complex()      # Real part 0, Imaginary part 0
print(f"Complex number 4: {complex_num4}")

            

              
                Copy
              
            
          

• Używanie składni a + bj:

Jest to bardziej powszechny i często bardziej czytelny sposób definiowania liczb zespolonych w Pythonie.

            # Creating complex numbers using a + bj syntax
complex_num_a = 4 + 6j
print(f"Complex number A: {complex_num_a}")

complex_num_b = -2 - 3j
print(f"Complex number B: {complex_num_b}")

complex_num_c = 9j       # Real part is 0
print(f"Complex number C: {complex_num_c}")

complex_num_d = 1 + 1j   # Equivalent to 1 + j
print(f"Complex number D: {complex_num_d}")

            

              
                Copy
              
            
          

Dostęp do części rzeczywistej i urojonej

Gdy masz obiekt liczby zespolonej, możesz łatwo uzyskać dostęp do jego składowych rzeczywistych i urojonych, używając odpowiednio atrybutów .real i .imag. Te atrybuty zawsze zwracają liczby zmiennoprzecinkowe.

            my_complex = 5.5 + 2.3j

print(f"The complex number is: {my_complex}")
print(f"Real part: {my_complex.real}")
print(f"Imaginary part: {my_complex.imag}")

            

              
                Copy
              
            
          

Typ liczb zespolonych

Typ liczby zespolonej w Pythonie jest odrębny. Możesz sprawdzić jego typ za pomocą type().

            z = 3 + 4j
print(f"Type of z: {type(z)}")

            

              
                Copy
              
            
          

Operacje matematyczne na liczbach zespolonych w postaci prostokątnej

Python obsługuje standardowe operacje arytmetyczne bezpośrednio na liczbach zespolonych, co czyni obliczenia matematyczne intuicyjnymi. Wyniki tych operacji są również liczbami zespolonymi.

Dodawanie i Odejmowanie

Dodawanie lub odejmowanie liczb zespolonych polega na dodawaniu lub odejmowaniu ich odpowiednich części rzeczywistych i urojonych.

Wzór:

(a + bi) + (c + di) = (a + c) + (b + d)i

(a + bi) - (c + di) = (a - c) + (b - d)i

            z1 = 2 + 3j
z2 = 1 - 5j

# Addition
sum_result = z1 + z2
print(f"{z1} + {z2} = {sum_result}")

# Subtraction
diff_result = z1 - z2
print(f"{z1} - {z2} = {diff_result}")

            

              
                Copy
              
            
          

Mnożenie

Mnożenie liczb zespolonych jest zgodne z właściwością rozdzielności, pamiętając, że j² = -1.

Wzór:

(a + bi) * (c + di) = ac + adi + bci + bdi² = (ac - bd) + (ad + bc)i

            z1 = 2 + 3j
z2 = 1 - 5j

# Multiplication
prod_result = z1 * z2
print(f"{z1} * {z2} = {prod_result}")

            

              
                Copy
              
            
          

Dzielenie

Dzielenie liczb zespolonych polega na pomnożeniu licznika i mianownika przez sprzężenie mianownika w celu usunięcia niewymierności z mianownika.

Wzór:

(a + bi) / (c + di) = ((a + bi) * (c - di)) / ((c + di) * (c - di)) = ((ac + bd) + (bc - ad)i) / (c² + d²)

            z1 = 2 + 3j
z2 = 1 - 5j

# Division
div_result = z1 / z2
print(f"{z1} / {z2} = {div_result}")

# Division by zero will raise a ZeroDivisionError
# zero_complex = 0 + 0j
# print(z1 / zero_complex)

            

              
                Copy
              
            
          

Sprzężenie

Sprzężeniem liczby zespolonej a + bj jest a - bj. W Pythonie metoda .conjugate() zwraca sprzężenie zespolone.

            z = 4 + 7j
conjugate_z = z.conjugate()
print(f"The conjugate of {z} is {conjugate_z}")

            

              
                Copy
              
            
          

Moduł (Wartość Bezwzględna)

Moduł lub wartość bezwzględna liczby zespolonej a + bj to jej odległość od początku układu współrzędnych na płaszczyźnie zespolonej, obliczona jako sqrt(a² + b²). Wbudowana funkcja Pythona abs() oblicza tę wartość.

Wzór:

|a + bi| = sqrt(a² + b²)

            z = 3 + 4j
magnitude_z = abs(z)
print(f"The magnitude of {z} is {magnitude_z}")

            

              
                Copy
              
            
          

Potęgowanie liczb zespolonych

Potęgowanie liczby zespolonej jest również obsługiwane. Dla potęg całkowitych jest to proste. Dla potęg ułamkowych lub zespolonych wyniki mogą być wielowartościowe i są zazwyczaj obsługiwane za pomocą logarytmów.

            z = 1 + 1j

# Squaring a complex number
squared_z = z ** 2
print(f"{z} squared is {squared_z}")

# Raising to a higher power
cubed_z = z ** 3
print(f"{z} cubed is {cubed_z}")

# Fractional power (can lead to multiple results)
# Python typically returns the principal value
sqrt_z = z ** 0.5
print(f"The square root of {z} is (principal value) {sqrt_z}")

            

              
                Copy
              
            
          

Potęga postaci biegunowej

Podczas gdy postać prostokątna (a + bj) jest intuicyjna dla podstawowej arytmetyki, postać biegunowa oferuje znaczące korzyści dla zrozumienia obrotu, mnożenia, dzielenia i potęgowania, szczególnie w inżynierii i fizyce.

Liczba zespolona może być również reprezentowana w postaci biegunowej jako r(cos θ + i sin θ), lub bardziej zwięźle za pomocą wzoru Eulera, re^iθ. Tutaj:

• r (moduł): Moduł lub odległość od początku układu współrzędnych (taka sama jak wartość bezwzględna obliczona wcześniej).
• θ (argument): Kąt (w radianach), który odcinek linii od początku układu współrzędnych do liczby zespolonej tworzy z dodatnią osią rzeczywistą.

Konwersja z postaci prostokątnej na biegunową

Biorąc pod uwagę liczbę zespoloną z = a + bj, możemy ją przekształcić do postaci biegunowej:

• Moduł (r): r = abs(z)
• Argument (θ): θ = atan2(b, a). Funkcja atan2(y, x) z modułu math (lub cmath) jest kluczowa, ponieważ poprawnie określa kąt we wszystkich czterech ćwiartkach, w przeciwieństwie do prostego atan(b/a).

Moduł cmath Pythona dostarcza funkcji do bezpośredniej pracy ze współrzędnymi biegunowymi.

            import cmath

z_rect = 3 + 4j

# Convert to polar coordinates
polar_coords = cmath.polar(z_rect)
radius = polar_coords[0]     # This is 'r'
angle_radians = polar_coords[1] # This is 'theta'

print(f"Rectangular: {z_rect}")
print(f"Polar: Radius = {radius:.2f}, Angle (radians) = {angle_radians:.2f}")

# For degrees, convert radians to degrees
angle_degrees = cmath.degrees(angle_radians)
print(f"Polar: Angle (degrees) = {angle_degrees:.2f}")

            

              
                Copy
              
            
          

Konwersja z postaci biegunowej na prostokątną

Biorąc pod uwagę liczbę zespoloną w postaci biegunowej r(cos θ + i sin θ) lub re^iθ, możemy ją przekształcić z powrotem do postaci prostokątnej:

• Część rzeczywista (a): a = r * cos(θ)
• Część urojona (b): b = r * sin(θ)

Moduł cmath Pythona posiada funkcję cmath.rect() do tego celu.

            import cmath

radius = 5.0
angle_radians = 0.927 # Approximately 53.13 degrees

# Convert from polar to rectangular coordinates
rectangular_coords = cmath.rect(radius, angle_radians)

print(f"Polar: Radius = {radius}, Angle (radians) = {angle_radians:.2f}")
print(f"Rectangular: {rectangular_coords}")

# Using degrees with cmath.rect is not direct; convert degrees to radians first
angle_degrees_example = 45.0
angle_radians_example = cmath.radians(angle_degrees_example)
rect_from_deg = cmath.rect(1.0, angle_radians_example)
print(f"Polar (45 deg): {rect_from_deg}")

            

              
                Copy
              
            
          

Operacje w postaci biegunowej

Prawdziwa potęga postaci biegunowej ujawnia się podczas wykonywania mnożenia, dzielenia i potęgowania. Te operacje stają się znacznie prostsze w porównaniu do ich odpowiedników w postaci prostokątnej.

Mnożenie w postaci biegunowej

Aby pomnożyć dwie liczby zespolone w postaci biegunowej, należy pomnożyć ich moduły i dodać ich argumenty.

Wzór:

Jeśli z1 = r1(cos θ1 + i sin θ1) i z2 = r2(cos θ2 + i sin θ2), to

z1 * z2 = (r1 * r2) * [cos(θ1 + θ2) + i sin(θ1 + θ2)]

Moduł cmath Pythona nie posiada bezpośredniej funkcji mnożenia, która przyjmuje wejścia biegunowe i zwraca wyniki biegunowe w jednym kroku. Zazwyczaj należy przekonwertować na postać prostokątną, pomnożyć, a następnie w razie potrzeby przekonwertować z powrotem, lub ręcznie zaimplementować logikę.

            import cmath

z1_rect = 2 + 3j
z2_rect = 1 - 5j

# Convert to polar
r1, theta1 = cmath.polar(z1_rect)
r2, theta2 = cmath.polar(z2_rect)

# Perform multiplication in polar domain
product_r = r1 * r2
product_theta = theta1 + theta2

# Convert the result back to rectangular
product_rect_polar_method = cmath.rect(product_r, product_theta)

# For comparison, direct multiplication in rectangular form
product_rect_direct = z1_rect * z2_rect

print(f"z1 = {z1_rect}, Polar: r={r1:.2f}, theta={cmath.degrees(theta1):.2f} deg")
print(f"z2 = {z2_rect}, Polar: r={r2:.2f}, theta={cmath.degrees(theta2):.2f} deg")
print(f"Product (Polar Method): {product_rect_polar_method}")
print(f"Product (Direct Method): {product_rect_direct}")

# Note: Small floating-point differences might occur

            

              
                Copy
              
            
          

Dzielenie w postaci biegunowej

Aby podzielić dwie liczby zespolone w postaci biegunowej, należy podzielić ich moduły i odjąć ich argumenty (argument licznika minus argument mianownika).

Wzór:

Jeśli z1 = r1(cos θ1 + i sin θ1) i z2 = r2(cos θ2 + i sin θ2), to

z1 / z2 = (r1 / r2) * [cos(θ1 - θ2) + i sin(θ1 - θ2)]

            import cmath

z1_rect = 2 + 3j
z2_rect = 1 - 5j

# Convert to polar
r1, theta1 = cmath.polar(z1_rect)
r2, theta2 = cmath.polar(z2_rect)

# Perform division in polar domain
quotient_r = r1 / r2
quotient_theta = theta1 - theta2

# Convert the result back to rectangular
quotient_rect_polar_method = cmath.rect(quotient_r, quotient_theta)

# For comparison, direct division in rectangular form
quotient_rect_direct = z1_rect / z2_rect

print(f"Quotient (Polar Method): {quotient_rect_polar_method}")
print(f"Quotient (Direct Method): {quotient_rect_direct}")

            

              
                Copy
              
            
          

Potęgowanie (Twierdzenie de Moivre'a)

Podniesienie liczby zespolonej w postaci biegunowej do całkowitej potęgi n jest uproszczone przez Twierdzenie de Moivre'a:

Wzór:

[r(cos θ + i sin θ)]ⁿ = rⁿ(cos(nθ) + i sin(nθ))

To twierdzenie jest niezwykle przydatne do obliczania pierwiastków liczb zespolonych i rozwiązywania równań wielomianowych. Dla potęg zespolonych rozszerza się je za pomocą logarytmów.

            import cmath

z_rect = 1 + 1j

# Convert to polar
r, theta = cmath.polar(z_rect)

n = 5  # The power

# Calculate z^n using De Moivre's Theorem
hesized_r = r ** n
hesized_theta = n * theta

# Convert the result back to rectangular
hesized_rect_polar_method = cmath.rect(hesized_r, hesized_theta)

# For comparison, direct exponentiation in Python
hesized_rect_direct = z_rect ** n

print(f"z = {z_rect}, Polar: r={r:.2f}, theta={cmath.degrees(theta):.2f} deg")
print(f"{z_rect}^{n} (Polar Method): {hesized_rect_polar_method}")
print(f"{z_rect}^{n} (Direct Method): {hesized_rect_direct}")

# Calculating roots (e.g., cube root, n=1/3)
n_root = 1/3

r_root = r ** n_root
theta_root_principal = n_root * theta

# The principal root
principal_root = cmath.rect(r_root, theta_root_principal)
print(f"Principal cube root of {z_rect}: {principal_root}")

# Note: For roots, there are 'n' distinct values. De Moivre's theorem applied directly
# usually gives the principal root. To find all roots, you'd add multiples of 2*pi/n to the angle.

for k in range(3):
    current_angle = (theta + 2 * cmath.pi * k) / 3
    root_k = cmath.rect(r_root, current_angle)
    print(f"Cube root {k+1}: {root_k}")

            

              
                Copy
              
            
          

Typowe funkcje dla liczb zespolonych w cmath

Moduł cmath dostarcza wiele zaawansowanych funkcji matematycznych, które operują na liczbach zespolonych, w tym funkcje trygonometryczne, hiperboliczne i logarytmiczne.

• cmath.sqrt(z): Oblicza pierwiastek kwadratowy z liczby zespolonej. Zwraca pierwiastek główny.
• cmath.exp(z): Oblicza e podniesione do potęgi z.
• cmath.log(z[, base]): Oblicza logarytm z. Jeśli określono base, oblicza logarytm o tej podstawie. W przeciwnym razie oblicza logarytm naturalny.
• cmath.sin(z), cmath.cos(z), cmath.tan(z): Funkcje trygonometryczne dla liczb zespolonych.
• cmath.sinh(z), cmath.cosh(z), cmath.tanh(z): Funkcje hiperboliczne dla liczb zespolonych.

            import cmath

z = 1 + 1j

# Square root
print(f"sqrt({z}) = {cmath.sqrt(z)}")

# Exponential
print(f"exp({z}) = {cmath.exp(z)}")

# Natural logarithm
print(f"log({z}) = {cmath.log(z)}")

# Sine
print(f"sin({z}) = {cmath.sin(z)}")

            

              
                Copy
              
            
          

Zastosowania liczb zespolonych

Liczby zespolone i ich reprezentacja biegunowa są niezastąpione w wielu dziedzinach nauki i inżynierii:

• Elektrotechnika: Szeroko stosowane w analizie obwodów prądu zmiennego, impedancji i przetwarzaniu sygnałów. Postać biegunowa jest naturalna do opisywania amplitudy i fazy prądów i napięć zmiennych.
• Przetwarzanie sygnałów: Transformacje Fouriera, które rozkładają sygnały na ich składowe częstotliwości, silnie opierają się na zespolonych funkcjach wykładniczych (e^iωt), naturalnie wyrażonych w postaci biegunowej.
• Mechanika kwantowa: Podstawowe równania mechaniki kwantowej, takie jak równanie Schrödingera, obejmują zespolone funkcje falowe.
• Systemy sterowania: Analiza stabilności systemu i odpowiedzi częstotliwościowej często wiąże się z liczbami zespolonymi w dziedzinie Laplace'a.
• Dynamika płynów: Niektóre problemy w mechanice płynów mogą być uproszczone za pomocą teorii potencjału zespolonego.
• Geometria fraktalna: Fraktale takie jak zbiór Mandelbrota są generowane przez iterowanie funkcji zespolonych.

Przykład globalny: Transformata Fouriera w przetwarzaniu dźwięku

Rozważmy przetwarzanie sygnałów audio na całym świecie. Podczas analizy fali dźwiękowej inżynierowie i analitycy danych używają Dyskretnej Transformaty Fouriera (DFT) lub jej wydajnej implementacji, Szybkiej Transformaty Fouriera (FFT). DFT przekształca sygnał z dziedziny czasu (jak zmienia się ciśnienie akustyczne w czasie) na jego reprezentację w dziedzinie częstotliwości. Ta reprezentacja to szereg liczb zespolonych, gdzie każda liczba zespolona odpowiada określonej częstotliwości. Moduł liczby zespolonej wskazuje amplitudę (głośność) tej składowej częstotliwości, a jej argument (kąt) wskazuje jej fazę. Pozwala to na wykonywanie zadań takich jak redukcja szumów, korekcja i synteza muzyki, które są standardem w globalnej produkcji i analizie audio.

Najlepsze praktyki korzystania z liczb zespolonych w Pythonie

• Wybierz właściwą postać: Dla podstawowej arytmetyki (dodawanie, odejmowanie) postać prostokątna jest często prostsza. Dla mnożenia, dzielenia i potęgowania/pierwiastkowania, zwłaszcza gdy chodzi o kąty i obroty, postać biegunowa (lub użycie funkcji cmath, które to abstrahują) jest zazwyczaj bardziej efektywna i koncepcyjnie jaśniejsza.
• Wykorzystaj cmath: Zawsze używaj modułu cmath do matematyki liczb zespolonych wykraczającej poza podstawową arytmetykę. Obsługuje on przypadki brzegowe i niezawodnie dostarcza zaawansowanych funkcji.
• Pamiętaj o precyzji zmiennoprzecinkowej: Podobnie jak w przypadku wszystkich obliczeń zmiennoprzecinkowych, wyniki z liczbami zespolonymi mogą zawierać niewielkie błędy precyzji. Zachowaj ostrożność podczas porównywania liczb zespolonych pod kątem dokładnej równości.
• Zrozum radiany: Funkcje trygonometryczne w modułach math i cmath Pythona działają na radianach. Upewnij się, że twoje kąty są w poprawnej jednostce.
• Używaj `atan2` dla kątów: Podczas ręcznego obliczania argumentu z części rzeczywistej i urojonej, użyj math.atan2(imaginary, real) lub cmath.phase(complex_number) w celu dokładnego określenia ćwiartki.

Podsumowanie

Wbudowana obsługa liczb zespolonych w Pythonie, uzupełniona potężnym modułem cmath, stanowi kompleksowy zestaw narzędzi do rozwiązywania szerokiego spektrum wyzwań matematycznych i naukowych. Niezależnie od tego, czy wykonujesz proste manipulacje algebraiczne, czy zagłębiasz się w elegancki świat współrzędnych biegunowych w celu wykonywania operacji takich jak obrót i skalowanie, Python zapewnia Ci przejrzystość i wydajność.

Dzięki zrozumieniu współzależności między postacią prostokątną a biegunową oraz rozważnemu stosowaniu funkcji dostarczanych przez bibliotekę standardową, deweloperzy i badacze na całym świecie mogą odkrywać nowe możliwości w dziedzinach od telekomunikacji i lotnictwa, po modelowanie finansowe i obliczenia kwantowe. Opanowanie tych koncepcji niewątpliwie zwiększy Twoje umiejętności rozwiązywania problemów w coraz bardziej złożonym i połączonym świecie.